package com.atguigu.tingshu.order.service.impl;

import com.alibaba.fastjson.JSON;
import com.atguigu.tingshu.account.client.UserAccountFeignClient;
import com.atguigu.tingshu.album.client.AlbumInfoFeignClient;
import com.atguigu.tingshu.album.client.TrackInfoFeignClient;
import com.atguigu.tingshu.common.constant.SystemConstant;
import com.atguigu.tingshu.common.execption.GuiguException;
import com.atguigu.tingshu.common.rabbit.constant.MqConst;
import com.atguigu.tingshu.common.rabbit.service.RabbitService;
import com.atguigu.tingshu.common.result.Result;
import com.atguigu.tingshu.common.result.ResultCodeEnum;
import com.atguigu.tingshu.model.album.AlbumInfo;
import com.atguigu.tingshu.model.album.TrackInfo;
import com.atguigu.tingshu.model.order.OrderDerate;
import com.atguigu.tingshu.model.order.OrderDetail;
import com.atguigu.tingshu.model.order.OrderInfo;
import com.atguigu.tingshu.model.user.VipServiceConfig;
import com.atguigu.tingshu.order.helper.SignHelper;
import com.atguigu.tingshu.order.mapper.OrderDerateMapper;
import com.atguigu.tingshu.order.mapper.OrderDetailMapper;
import com.atguigu.tingshu.order.mapper.OrderInfoMapper;
import com.atguigu.tingshu.order.service.OrderInfoService;
import com.atguigu.tingshu.user.client.UserInfoFeignClient;
import com.atguigu.tingshu.user.client.VipServiceConfigFeignClient;
import com.atguigu.tingshu.vo.account.AccountDeductVo;
import com.atguigu.tingshu.vo.order.OrderDerateVo;
import com.atguigu.tingshu.vo.order.OrderDetailVo;
import com.atguigu.tingshu.vo.order.OrderInfoVo;
import com.atguigu.tingshu.vo.order.TradeVo;
import com.atguigu.tingshu.vo.user.UserInfoVo;
import com.atguigu.tingshu.vo.user.UserPaidRecordVo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;
import org.springframework.util.ObjectUtils;

import java.math.BigDecimal;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

@Slf4j
@Service
@SuppressWarnings({"all"})
public class OrderInfoServiceImpl extends ServiceImpl<OrderInfoMapper, OrderInfo> implements OrderInfoService {

    @Autowired
    private OrderInfoMapper orderInfoMapper;

    @Autowired
    private AlbumInfoFeignClient albumInfoFeignClient;

    @Autowired
    private UserInfoFeignClient userInfoFeignClient;

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private VipServiceConfigFeignClient vipServiceConfigFeignClient;

    @Autowired
    private TrackInfoFeignClient trackInfoFeignClient;

    @Autowired
    private OrderDetailMapper orderDetailMapper;

    @Autowired
    private OrderDerateMapper orderDerateMapper;

    @Autowired
    private UserAccountFeignClient userAccountFeignClient;

    @Autowired
    private RabbitService rabbitService;


    @Override
/**
 * 处理交易请求，生成订单信息
 *
 * @param tradeVo 包含交易详情的对象
 * @param userId 用户ID
 * @return 返回生成的订单信息对象
 */
//    public OrderInfoVo trade(TradeVo tradeVo, Long userId) {
//        // 生成一个订单vo，用作返回处理
//        OrderInfoVo orderInfoVo = new OrderInfoVo();
//        // 给返回的订单vo赋值
//        orderInfoVo.setTradeNo(UUID.randomUUID().toString().replaceAll("-", ""));
//        orderInfoVo.setPayWay("");
//        orderInfoVo.setItemType(tradeVo.getItemType());
//        List<OrderDetailVo> orderDetailVos = new ArrayList<>();
//        ArrayList<OrderDerateVo> orderDerateVos = new ArrayList<>();
//        // 查看付费项目类型
//        if (SystemConstant.ORDER_ITEM_TYPE_ALBUM.equals(tradeVo.getItemType())) {
//            // 先判断是否购买了专辑
//            Result<Boolean> paidAlbum = userInfoFeignClient.isPaidAlbum(tradeVo.getItemId());
//            Assert.notNull(paidAlbum, "查询用户是否购买专辑失败");
//            Boolean flag = paidAlbum.getData();
//            Assert.notNull(flag, "查询用户是否购买专辑失败");
//            if (flag) {
//                throw new GuiguException(20001, "您已经购买了该专辑");
//            }
//            // 付费的是专辑
//            // 远程调用查询专辑的价格
//            Result<AlbumInfo> albumInfoVo = albumInfoFeignClient.getAlbumInfo(tradeVo.getItemId());
//            // 判断远程调用的结果是否为空
//            Assert.notNull(albumInfoVo, "查询专辑价格失败");
//            // 获取结果里的数据
//            AlbumInfo albumInfo = albumInfoVo.getData();
//            // 判断结果里的数据是否为空
//            Assert.notNull(albumInfo, "查询专辑价格失败");
//            // 给订单价格赋值
//            orderInfoVo.setOriginalAmount(albumInfo.getPrice());
//            // 判断用户是否是vip
//            Result<UserInfoVo> userInfoVo = userInfoFeignClient.getUserInfoVo(userId);
//            Assert.notNull(userInfoVo, "查询用户信息失败");
//            UserInfoVo userInfo = userInfoVo.getData();
//            Assert.notNull(userInfo);
//            BigDecimal derate = new BigDecimal("0.00");
//            if (userInfo.getIsVip() == 0 || (userInfo.getIsVip() == 1 && userInfo.getVipExpireTime().before(new Date()))) {
//                // 表示不是vip
//                // 判断是否有折扣
//                if (albumInfo.getDiscount().compareTo(new BigDecimal("-1")) > 0) {
//                    // 表示折扣不为-1,表示有折扣
//                    // 计算出折扣，并添加打折金额
//                    derate = orderInfoVo.getOriginalAmount().multiply(new BigDecimal("10").subtract(albumInfo.getDiscount())).divide(new BigDecimal("10"),2,BigDecimal.ROUND_HALF_UP);
//                    // 给orderinfoVo属性赋值
//                    orderInfoVo.setDerateAmount(derate);
//                }
//            } else {
//                // 表示是vip
//                // 判断是否有折扣
//                if (albumInfo.getVipDiscount().compareTo(new BigDecimal("-1")) > 0) {
//                    // 表示折扣不为-1,表示有折扣
//                    // 计算出折扣，并添加打折金额
//                    derate = orderInfoVo.getOriginalAmount().multiply(new BigDecimal("10").subtract(albumInfo.getDiscount())).divide(new BigDecimal("10"),2,BigDecimal.ROUND_HALF_UP);
//                    // 给orderinfoVo属性赋值
//                    orderInfoVo.setDerateAmount(derate);
//                }
//            }
//            // 给订单实际金额赋值
//            orderInfoVo.setOrderAmount(orderInfoVo.getOriginalAmount().subtract(derate));
//            OrderDetailVo orderDetailVo = new OrderDetailVo();
//            orderDetailVo.setItemId(tradeVo.getItemId());
//            orderDetailVo.setItemName(albumInfo.getAlbumTitle());
//            orderDetailVo.setItemPrice(orderInfoVo.getDerateAmount());
//            orderDetailVo.setItemUrl(albumInfo.getCoverUrl());
//            orderDetailVos.add(orderDetailVo);
//            // 先判断是否有折扣
//            if (derate.compareTo(new BigDecimal("0.00")) > 0) {
//                OrderDerateVo orderDerateVo = new OrderDerateVo();
//                orderDerateVo.setDerateType(SystemConstant.ORDER_DERATE_ALBUM_DISCOUNT);
//                orderDerateVo.setDerateAmount(derate);
//                orderDerateVo.setRemarks("专辑折扣");
//                orderDerateVos.add(orderDerateVo);
//            }
//        } else if (SystemConstant.ORDER_ITEM_TYPE_TRACK.equals(tradeVo.getItemType())) {
//            // 付费的是声音
//        } else {
//            // 付费的是vip
//            // 远程调用对应vip的信息
//            Result<VipServiceConfig> vipServiceConfigVo = vipServiceConfigFeignClient.getVipServiceConfig(tradeVo.getItemId());
//            Assert.notNull(vipServiceConfigVo, "查询vip信息失败");
//            VipServiceConfig vipServiceConfig = vipServiceConfigVo.getData();
//            orderInfoVo.setOriginalAmount(vipServiceConfig.getPrice());
//            orderInfoVo.setOrderAmount(vipServiceConfig.getDiscountPrice());
//            BigDecimal derate = vipServiceConfig.getPrice().subtract(vipServiceConfig.getDiscountPrice());
//            orderInfoVo.setDerateAmount(derate);
//            OrderDetailVo orderDetailVo = new OrderDetailVo();
//            orderDetailVo.setItemId(tradeVo.getItemId());
//            orderDetailVo.setItemUrl(vipServiceConfig.getImageUrl());
//            orderDetailVo.setItemName(vipServiceConfig.getName());
//            orderDetailVo.setItemPrice(vipServiceConfig.getDiscountPrice());
//            orderDetailVos.add(orderDetailVo);
//            if (derate.compareTo(new BigDecimal("0.00")) > 0) {
//                OrderDerateVo orderDerateVo = new OrderDerateVo();
//                orderDerateVo.setDerateAmount(derate);
//                orderDerateVo.setDerateType(SystemConstant.ORDER_DERATE_VIP_SERVICE_DISCOUNT);
//                orderDerateVo.setRemarks("vip服务折扣");
//                orderDerateVos.add(orderDerateVo);
//            }
//        }
//        orderInfoVo.setOrderDetailVoList(orderDetailVos);
//        orderInfoVo.setOrderDerateVoList(orderDerateVos);
//        orderInfoVo.setTimestamp(System.currentTimeMillis());
//        String sign = SignHelper.getSign(JSON.parseObject(JSON.toJSONString(orderInfoVo), Map.class));
//        orderInfoVo.setSign(sign);
//        return orderInfoVo;
//    }
    public OrderInfoVo trade(TradeVo tradeVo, Long userId) {
        // 生成一个订单vo，用作返回处理
        OrderInfoVo orderInfoVo = new OrderInfoVo();
//        生成一个uuid当作订单号
        String tradeNo = UUID.randomUUID().toString().replaceAll("-", "");
//        生成redis的key
        String redisKey = userId+":trade:"+tradeNo;
//        需要将订单号上传到缓存中，防止订单的重复提交
        redisTemplate.opsForValue().setIfAbsent(redisKey, tradeNo, 10, TimeUnit.MINUTES);
        // 给返回的订单vo赋值
        orderInfoVo.setTradeNo(tradeNo); // 生成唯一的交易号
        orderInfoVo.setPayWay(""); // 设置支付方式（默认为空）
        orderInfoVo.setItemType(tradeVo.getItemType()); // 设置订单项类型（专辑、声音、VIP等）

        // 初始化订单详情列表和折扣列表
        List<OrderDetailVo> orderDetailVos = new ArrayList<>();
        List<OrderDerateVo> orderDerateVos = new ArrayList<>();

        // 查看付费项目类型
        if (SystemConstant.ORDER_ITEM_TYPE_ALBUM.equals(tradeVo.getItemType())) {
            // 付费的是专辑
            // 先判断是否购买了专辑
            Result<Boolean> paidAlbum = userInfoFeignClient.isPaidAlbum(tradeVo.getItemId());
            Assert.notNull(paidAlbum, "查询用户是否购买专辑失败"); // 检查远程调用结果是否为空
            Boolean flag = paidAlbum.getData();
            Assert.notNull(flag, "查询用户是否购买专辑失败"); // 检查数据是否为空
            if (flag) {
                throw new GuiguException(20001, "您已经购买了该专辑"); // 如果已购买，抛出异常
            }

            // 远程调用查询专辑的价格
            Result<AlbumInfo> albumInfoVo = albumInfoFeignClient.getAlbumInfo(tradeVo.getItemId());
            Assert.notNull(albumInfoVo, "查询专辑价格失败"); // 检查远程调用结果是否为空
            AlbumInfo albumInfo = albumInfoVo.getData();
            Assert.notNull(albumInfo, "查询专辑价格失败"); // 检查数据是否为空

            // 给订单价格赋值
            orderInfoVo.setOriginalAmount(albumInfo.getPrice()); // 设置订单原始金额

            // 判断用户是否是VIP
            Result<UserInfoVo> userInfoVo = userInfoFeignClient.getUserInfoVo(userId);
            Assert.notNull(userInfoVo, "查询用户信息失败"); // 检查远程调用结果是否为空
            UserInfoVo userInfo = userInfoVo.getData();
            Assert.notNull(userInfo, "查询用户信息失败"); // 检查数据是否为空

            BigDecimal derate = new BigDecimal("0.00"); // 初始化折扣金额
            if (userInfo.getIsVip() == 0 || (userInfo.getIsVip() == 1 && userInfo.getVipExpireTime().before(new Date()))) {
                // 表示不是VIP或VIP已过期
                // 判断是否有折扣
                if (albumInfo.getDiscount().compareTo(new BigDecimal("-1")) > 0) {
                    // 表示折扣不为-1，表示有折扣
                    // 计算出折扣，并添加打折金额
                    derate = orderInfoVo.getOriginalAmount().multiply(new BigDecimal("10").subtract(albumInfo.getDiscount())).divide(new BigDecimal("10"), 2, BigDecimal.ROUND_HALF_UP);
                    orderInfoVo.setDerateAmount(derate); // 设置折扣金额
                }
            } else {
                // 表示是VIP
                // 判断是否有VIP折扣
                if (albumInfo.getVipDiscount().compareTo(new BigDecimal("-1")) > 0) {
                    // 表示折扣不为-1，表示有折扣
                    // 计算出折扣，并添加打折金额
                    derate = orderInfoVo.getOriginalAmount().multiply(new BigDecimal("10").subtract(albumInfo.getDiscount())).divide(new BigDecimal("10"), 2, BigDecimal.ROUND_HALF_UP);
                    orderInfoVo.setDerateAmount(derate); // 设置折扣金额
                }
            }

            // 给订单实际金额赋值
            orderInfoVo.setOrderAmount(orderInfoVo.getOriginalAmount().subtract(derate)); // 设置订单实际金额（原始金额减去折扣）

            // 创建订单详情
            OrderDetailVo orderDetailVo = new OrderDetailVo();
            orderDetailVo.setItemId(tradeVo.getItemId()); // 设置订单项ID
            orderDetailVo.setItemName(albumInfo.getAlbumTitle()); // 设置订单项名称
            orderDetailVo.setItemPrice(orderInfoVo.getDerateAmount()); // 设置订单项价格
            orderDetailVo.setItemUrl(albumInfo.getCoverUrl()); // 设置订单项封面URL
            orderDetailVos.add(orderDetailVo); // 将订单详情添加到列表

            // 判断是否有折扣
            if (derate.compareTo(new BigDecimal("0.00")) > 0) {
                // 如果有折扣，创建折扣信息
                OrderDerateVo orderDerateVo = new OrderDerateVo();
                orderDerateVo.setDerateType(SystemConstant.ORDER_DERATE_ALBUM_DISCOUNT); // 设置折扣类型
                orderDerateVo.setDerateAmount(derate); // 设置折扣金额
                orderDerateVo.setRemarks("专辑折扣"); // 设置折扣备注
                orderDerateVos.add(orderDerateVo); // 将折扣信息添加到列表
            }
        } else if (SystemConstant.ORDER_ITEM_TYPE_TRACK.equals(tradeVo.getItemType())) {
            // 付费的是声音（未实现具体逻辑）
//            如果购买的声音小于0，直接抛出异常
            if(tradeVo.getTrackCount()<0){
                throw new GuiguException(20001, "购买数量不能小于0");
            }
//            先查询出所有要购买的声音
            Result<List<TrackInfo>>  list =  trackInfoFeignClient.getTrackInfoList(tradeVo.getItemId(),tradeVo.getTrackCount());
            Assert.notNull(list, "查询声音失败");
            List<TrackInfo> trackInfoList = list.getData();
//            查看声音对应的专辑列表
            Result<AlbumInfo> albumInfoVo = albumInfoFeignClient.getAlbumInfo(trackInfoList.get(0).getAlbumId());
            Assert.notNull(albumInfoVo, "查询专辑失败");
            AlbumInfo albumInfo = albumInfoVo.getData();
            Assert.notNull(albumInfo, "查询专辑失败");
            orderInfoVo.setOriginalAmount(tradeVo.getTrackCount()==0?albumInfo.getPrice():albumInfo.getPrice().multiply(new BigDecimal(String.valueOf(tradeVo.getTrackCount()))));
            orderInfoVo.setOrderAmount(tradeVo.getTrackCount()==0?albumInfo.getPrice():albumInfo.getPrice().multiply(new BigDecimal(String.valueOf(tradeVo.getTrackCount()))));
            orderDetailVos = trackInfoList.stream().map(trackInfo -> {
                OrderDetailVo orderDetailVo = new OrderDetailVo();
                orderDetailVo.setItemId(trackInfo.getId());
                orderDetailVo.setItemName(trackInfo.getTrackTitle());
                orderDetailVo.setItemUrl(trackInfo.getCoverUrl());
                orderDetailVo.setItemPrice(albumInfo.getPrice());
                return orderDetailVo;
            }).collect(Collectors.toList());
        } else {
            // 付费的是VIP
            // 远程调用对应VIP的信息
            Result<VipServiceConfig> vipServiceConfigVo = vipServiceConfigFeignClient.getVipServiceConfig(tradeVo.getItemId());
            Assert.notNull(vipServiceConfigVo, "查询VIP信息失败"); // 检查远程调用结果是否为空
            VipServiceConfig vipServiceConfig = vipServiceConfigVo.getData();

            // 设置订单金额
            orderInfoVo.setOriginalAmount(vipServiceConfig.getPrice()); // 设置原始金额
            orderInfoVo.setOrderAmount(vipServiceConfig.getDiscountPrice()); // 设置实际金额
            BigDecimal derate = vipServiceConfig.getPrice().subtract(vipServiceConfig.getDiscountPrice()); // 计算折扣金额
            orderInfoVo.setDerateAmount(derate); // 设置折扣金额

            // 创建订单详情
            OrderDetailVo orderDetailVo = new OrderDetailVo();
            orderDetailVo.setItemId(tradeVo.getItemId()); // 设置订单项ID
            orderDetailVo.setItemUrl(vipServiceConfig.getImageUrl()); // 设置订单项封面URL
            orderDetailVo.setItemName(vipServiceConfig.getName()); // 设置订单项名称
            orderDetailVo.setItemPrice(vipServiceConfig.getDiscountPrice()); // 设置订单项价格
            orderDetailVos.add(orderDetailVo); // 将订单详情添加到列表

            // 判断是否有折扣
            if (derate.compareTo(new BigDecimal("0.00")) > 0) {
                // 如果有折扣，创建折扣信息
                OrderDerateVo orderDerateVo = new OrderDerateVo();
                orderDerateVo.setDerateAmount(derate); // 设置折扣金额
                orderDerateVo.setDerateType(SystemConstant.ORDER_DERATE_VIP_SERVICE_DISCOUNT); // 设置折扣类型
                orderDerateVo.setRemarks("VIP服务折扣"); // 设置折扣备注
                orderDerateVos.add(orderDerateVo); // 将折扣信息添加到列表
            }
        }

        // 设置订单详情和折扣信息
        orderInfoVo.setOrderDetailVoList(orderDetailVos); // 设置订单详情列表
        orderInfoVo.setOrderDerateVoList(orderDerateVos); // 设置折扣信息列表

        // 设置时间戳和签名
        orderInfoVo.setTimestamp(System.currentTimeMillis()); // 设置时间戳
        String sign = SignHelper.getSign(JSON.parseObject(JSON.toJSONString(orderInfoVo), Map.class)); // 生成签名
        orderInfoVo.setSign(sign); // 设置签名

        return orderInfoVo; // 返回订单信息
    }

//    @GlobalTranSactional
    @Override
    public String submitOrder(OrderInfoVo orderInfoVo, Long userId) {
//        防止订单重复提交
//        获取到订单号
        String tradeNo = orderInfoVo.getTradeNo();
//        从redis中获取订单号
        String key = userId+":trade:"+tradeNo;
//        执行lua脚本比较如果正确就删除
        String scriptText = "if redis.call(\"get\",KEYS[1]) == ARGV[1]\n" +
                "then\n" +
                "    return redis.call(\"del\",KEYS[1])\n" +
                "else\n" +
                "    return 0\n" +
                "end";
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
        redisScript.setScriptText(scriptText);
        redisScript.setResultType(Long.class);
        Long count = (Long) this.redisTemplate.execute(redisScript, Arrays.asList(key), tradeNo);
//        如果影响的行数为0，就表示重复提交了
        if (count == 0) {
            throw new GuiguException(ResultCodeEnum.REPEAT_BUY_ERROR);
        }
//        将订单信息转化为map
        Map map = JSON.parseObject(JSON.toJSONString(orderInfoVo), Map.class);
        //        在校验签名的时候，需要先将支付方式设置为空
        map.put("payWay", "");
//        校验订单签名
        SignHelper.checkSign(map);
//        生成一个订单号
        String orderNo = UUID.randomUUID().toString().replaceAll("-", "");
//        判断支付类型
        if (SystemConstant.ORDER_PAY_WAY_WEIXIN.equals(orderInfoVo.getPayWay())){
//            表示微信支付
//            保存订单明细跟减免
            this.saveOrder(orderInfoVo,userId,orderNo);
//              发送延迟消息，防止订单超时没处理
            rabbitService.sendDealyMessage(MqConst.EXCHANGE_ORDER,MqConst.ROUTING_CANCEL_ORDER,orderNo,MqConst.CANCEL_ORDER_DELAY_TIME);

        }else {
//            表示余额支付
//            保存订单明细跟减免
            saveOrder(orderInfoVo,userId,orderNo);
//            保存之后去查余额,并扣除
//            因为余额在订单表,所以需要远程调用
//            生成一个新的AccountDeductVo对象
            AccountDeductVo accountDeductVo = new AccountDeductVo();
//            为其属性赋值
            accountDeductVo.setOrderNo(orderNo);
            accountDeductVo.setAmount(orderInfoVo.getOrderAmount());
            accountDeductVo.setContent(orderInfoVo.getOrderDetailVoList().get(0).getItemName());
            accountDeductVo.setUserId(userId);
//            远程调用去扣减金额
            Result result = userAccountFeignClient.checkAndDeduct(accountDeductVo);
            if (200!= result.getCode()){
                throw new GuiguException(ResultCodeEnum.ACCOUNT_LESS);
            }
//            修改订单状态
            OrderInfo orderInfo = this.getOrderInfo(orderNo);
            orderInfo.setOrderStatus(SystemConstant.ORDER_STATUS_PAID);
            this.updateById(orderInfo);
//            远程调用去存储已支付的支付记录
//            新建一个传递参数的对象
            UserPaidRecordVo userPaidRecordVo = new UserPaidRecordVo();
//            给userPaidRecordVo对象赋值
            userPaidRecordVo.setOrderNo(orderNo);
            userPaidRecordVo.setUserId(userId);
            userPaidRecordVo.setItemType(orderInfoVo.getItemType());
            userPaidRecordVo.setItemIdList(orderInfoVo.getOrderDetailVoList().stream().map(OrderDetailVo::getItemId).collect(Collectors.toList()));
//            远程调用去保存相应的购买记录
            Result result1 = userInfoFeignClient.saveUserPaidRecord(userPaidRecordVo);
            if (200!=result1.getCode()){
                throw new GuiguException(211,"新增购买记录异常");
            }
        }
//        返回交易号
        return orderNo;
    }
    @Transactional(rollbackFor = Exception.class)
    private void saveOrder(OrderInfoVo orderInfoVo, Long userId,String orderNo) {
//        生成一个orderInfo对象
        OrderInfo orderInfo = new OrderInfo();
//        属性拷贝
        BeanUtils.copyProperties(orderInfoVo,orderInfo);
//        为其他属性赋值
        orderInfo.setOrderNo(orderNo);
        orderInfo.setUserId(userId);
        orderInfo.setOrderStatus(SystemConstant.ORDER_STATUS_UNPAID);
        orderInfo.setOrderTitle(orderInfoVo.getOrderDetailVoList().get(0).getItemName());
//        调用mapper层的方法去插入
        orderInfoMapper.insert(orderInfo);
//        插入订单明细表
        orderInfoVo.getOrderDetailVoList().stream().forEach(orderDetailVo -> {
//            生成一个orderDetail对象
            OrderDetail orderDetail = new OrderDetail();
//            属性拷贝
            BeanUtils.copyProperties(orderDetailVo,orderDetail);
//            为其他属性赋值
            orderDetail.setOrderId(orderInfo.getId());
//            调用mapper服务去插入
            orderDetailMapper.insert(orderDetail);
        });
//        插入订单减免表
//        获取订单减免列表
        List<OrderDerateVo> orderDerateVoList = orderInfoVo.getOrderDerateVoList();
        if (!ObjectUtils.isEmpty(orderDerateVoList)){
            orderDerateVoList.stream().forEach(orderDerateVo -> {
//                生成一个orderDerate对象
                OrderDerate orderDerate = new OrderDerate();
//                属性拷贝
                BeanUtils.copyProperties(orderDerateVo,orderDerate);
//                设置其他属性
                orderDerate.setOrderId(orderInfo.getId());
//                插入订单减免表
                orderDerateMapper.insert(orderDerate);
            });
        }
    }

    @Override
    public OrderInfo getOrderInfo(String orderNo) {
//        去设置具体的过滤条件
        LambdaQueryWrapper<OrderInfo> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(OrderInfo::getOrderNo,orderNo);
//        从数据库中查询
        OrderInfo orderInfo = orderInfoMapper.selectOne(queryWrapper);
        orderInfo.setPayWayName(SystemConstant.ORDER_PAY_ACCOUNT.equals(orderInfo.getPayWay())?"余额":"线上");
        return orderInfo;
    }

    @Override
    public void cancelOrder(String orderNo) {
//        设置订单状态为取消
        OrderInfo orderInfo = orderInfoMapper.selectOne(new LambdaQueryWrapper<OrderInfo>().eq(OrderInfo::getOrderNo, orderNo));
        orderInfo.setOrderStatus(SystemConstant.ORDER_STATUS_CANCEL);
//        调用mapper层方法去修改
        orderInfoMapper.updateById(orderInfo);
    }

    @Override
    public IPage<OrderInfo> findUserPage(Page<OrderInfo> page, Long userId) {
        return orderInfoMapper.findUserPage(page,userId);
    }
}
